﻿#include<iostream>
using namespace std;

//初始化列表


//class Date
//{
//public:
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//class Date
//{
//public:
//	Date(int year, int month, int day)
//	{
//		_year = year; // 第一次赋值
//		_year = 2022; // 第二次赋值
//		//...还可以赋值很多次
//
//		_month = month;
//		_day = day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//class Date
//{
//public:
//	Date(int year=1, int month=1, int day=1)
//		:_year(year), _month(month), _day(day)
//	{
//	
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1; // 类对象的整体初始化
//			 //（初始化了类对象，但没有初始化成员变量），成员变量放到了初始化列表里面解决
//
//	return 0;
//}

//class Date
//{
//private:
//	int& _year; // 引用成员变量只能在定义时初始化
//};

//class A
//{
//public:
//	A()
//	{}
//
//private:
//	int a;
//	const int a1 = 1;//这是缺省参数的用法，不是初始化
//	int& b = a;
//};
//
//int main()
//{
//	A d1;
//
//	return 0;
//}

//class A 
//{
//public:
//	A(int val) //注：这个不叫默认构造函数（因为需要传参调用）
//	{
//		_val = val;
//	}
//private:
//	int _val;
//};
//
//class B
//{
//public:
//	B()
//		:_a(2021) //所以必须使用初始化列表对其进行初始化
//	{}
//private:
//	A _a; //自定义类型成员（该类没有默认构造函数）⬆
//};

//// Date类
//class Date
//{
//public:
//	Date(int day = 0)
//	{
//		_day = day;
//	}
//private:
//	int _day;
//};
//
//// Test类
//class Test
//{
//public:
//	Test(int day)
//		:_d(12)//调用Date的构造函数
//	{}
//	//这样用初始化列表，只用调用一次Date类的构造函数
//
//
//	Test(int day)
//	{ 
//		Date t(day);
//		_d = t;
//	}
//	//这样写的话，会调用两次Date类的构造函数
//	//因为系统在自动生成初始化列表时就会调用一次，之后在{ }里面又会调用一次
//
//private:
//	Date _d;
//};

//int i = 0;
//
//class Test
//{
//public:
//	Test()
//		:_b(i++)
//		, _a(i++)
//	{}
//	void Print()
//	{
//		cout << "_a:" << _a << endl;
//		cout << "_b:" << _b << endl;
//	}
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//	Test test;
//	test.Print();
//	return 0;
//}  


//----------------------------------------------------------

//static成员

//class Test1
//{
//private:
//	int _n;
//};
//
//class Test2
//{
//private:
//	int _n;
//	static int _aaa;
//};
//
//int main()
//{
//	cout << sizeof(Test1) << endl;
//	cout << sizeof(Test2) << endl;
//	return 0;
//}

//class Date
//{
//private:
//	static int _year;
//	static int _month;
//	static int _day;
//};
//
//// 静态成员变量的定义初始化
//int Date::_year = 2023;
//int Date::_month = 5;
//int Date::_day = 8;

//class Date
//{
//public:
//	static void Print()
//	{
//		cout << _year << "-" << _month << endl;
//	}
//private:
//	static int _year;
//	static int _month;
//};
//
//int Date::_year = 2022;
//int Date::_month = 10;
//
//int main()
//{
//	Date d1;
//
//	d1.Print(); // 对象.静态成员变量
//
//	Date::Print(); // 类名::静态成员函数
//	return 0;
//}

//class Date
//{
//public:
//	static void Print()
//	{
//		cout << _year << endl; //静态的成员可以访问
//		cout << _month << endl; //不能访问非静态成员
//	}
//private:
//	static int _year;
//	int _month;
//};
//
//int Date::_year = 2022;
//
//int main()
//{
//	Date d1;
//
//	d1.Print(); // 对象.静态成员
//
//	return 0;
//}

//class Date
//{
//public:
//
//private:
//	static int _year;
//};
//
////静态成员变量的定义初始化
//int Date::_year = 2023;
//
//int main()
//{
//	Date d1;
//
//	cout << d1._year << endl;
//	cout << Date()._year << endl;
//	cout << Date::_year << endl;
//
//	return 0;
//}


//class Date
//{
//public:
//	static int GetMonth()
//	{
//		return _month;
//	}
//	static int _year;
//private:
//	static int _month;
//};
//
////静态成员变量的定义初始化
//int Date::_year = 2023;
//int Date::_month = 5;
//
//
//int main()
//{
//	Date d1;
//
//	//对公共属性的静态成员进行访问
//	cout << d1._year << endl; // 1.通过类对象突破类域进行访问
//	cout << Date()._year << endl; // 2.通过匿名对象突破类域进行访问
//	cout << Date::_year << endl; // 3.通过类名突破类域进行访问
//
//	//对私有属性的静态成员进行访问
//	cout << d1.GetMonth() << endl; // 1.通过类对象突破类域进行访问
//	cout << Date().GetMonth() << endl; // 2.通过匿名对象突破类域进行访问
//	cout << Date::GetMonth() << endl; // 3.通过类名突破类域进行访问
//
//	return 0;
//}


// -------------------------------------------------------------------------

//友元的学习


//#include <iostream>
//using std::cin;
//using std::cout;
//using std::endl;

//class Date
//{
//public:
//    Date(int year, int month, int day)
//        : _year(year)
//        , _month(month)
//        , _day(day)
//    {}
//
//    std::ostream& operator<<(std::ostream& out)
//    {
//        out << _year << "-" << _month << "-" << _day;
//        return out;
//    }
//private:
//    int _year;
//    int _month;
//    int _day;
//};
//
//int main()
//{
//    Date d(2017, 12, 24);
//    cout << d;
//
//    return 0;
//}

//class Date
//{
//	//友元函数
//	// 标准流输出 --> printf
//	friend std::ostream& operator<<(std::ostream& out, const Date& d); 
//	// 标准流插入 --> scanf
//	friend std::istream& operator>>(std::istream& in, Date& d); 
//public:
//	Date(int year = 2023, int month = 5, int day = 8)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//// <<运算符重载---输入
//ostream& operator<<(std::ostream& out, const Date& d) 
//{
//	out << d._year << "-" << d._month << "-" << d._day << endl;
//	return out;
//}
//
//// >>运算符重载---输出
//istream& operator>>(std::istream& in, Date& d) 
//{
//	in >> d._year >> d._month >> d._day;
//	return in;
//}
//
//int main()
//{
//	Date d;
//	cin >> d;
//	cout << d << endl;
//	return 0;
//}


//class Time
//{
//	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
//public:
//	Time(int hour = 12, int minute = 0, int second = 0)
//		: _hour(hour)
//		, _minute(minute)
//		, _second(second)
//	{}
//
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//
//class Date
//{
//public:
//	Date(int year = 2023, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//
//	void SetTimeOfDate(int hour, int minute, int second)
//	{
//		// 直接访问时间类私有的成员变量
//		_t._hour = hour;
//		_t._minute = minute;
//		_t._second = second;
//	}
//private:
//	// 内置类型成员
//	int _year;
//	int _month;
//	int _day;
//
//	// 自定义类型成员
//	Time _t;
//};
//int main()
//{
//	return 0;
//}


//-----------------------------------------------------------------
 
//内部类学习


//class A
//{
//public:
//	// 内部类
//	class B // B天生就是A的友元，在B里面可以直接访问A的私有成员
//	{
//	public:
//		void Print(const A& a)
//		{
//			cout << y << endl; // 可以直接访问静态成员
//			cout << a.h << endl; // 也可以访问普通成员
//		}
//	private:
//		int _b;
//	};
//
//private:
//	static int y;
//	int h;
//};
//
//int A::y = 1;
//
//int main()
//{
//	A a; // 定义a对象
//
//	A::B bb; // 定义bb对象
//
//	bb.Print(a); // 把a对象传给bb对象，打印
//	return 0;
//}


//--------------------------------------------

//匿名对象

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//	int add(int n)
//	{
//		//...
//		return n;
//	}
//
//private:
//	int _a;
//};
//
//int main()
//{
//	A aa1;
//
//	A();
//
//	return 0;
//}


class Solution {
public:
	int Sum_Solution(int n) 
	{
		//...
		return n;
	}
};
int main()
{
	Solution aaa;
	cout << aaa.Sum_Solution(10) << endl;

	cout << Solution().Sum_Solution(10) << endl;

	return 0;
}
